import { _decorator, Component, Node, SpriteAtlas } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('Config')
export default class Config {
    // 版本号
    static versionCode: string = "1.0.0"
    // 游戏名
    static gameName: string = "掌上趣消消"

    // 连消内时间
    static comboDuration:number = 6
    // 关卡配置
    static levelConfig: object
    // 词库卡配置
    static wordsConfig: object
    // 规则配置
    static ruleConfig: object
    // 官职配置
    static guanzhiConfig: object
    // 金钱配置
    static moneyConfig: object
    // 合图
    static atlas: SpriteAtlas[] = []
    // 设备性能等级
    static benchmarkLevel = -1
    // 字的一行的数量
    static wordLineCount: number = 80
    // 每过 15 分钟体力加一
    static staminaAddDuration: number = 15 * 60
    // 最大体力
    static maxStamina: number = 6
    // 观看视频后增加的金币
    static videoAddMoney: number = 100
    // 总的槽数量
    static maxSlotCount: number = 10

    // 检查规则
    static checkRule(id1: number, id2: number) {        
        for (let index in Config.ruleConfig) {
            const indexValue = parseInt(index)
            if (indexValue > 0) {
                const checkA = Config.ruleConfig[index]["A"]
                const checkB = Config.ruleConfig[index]["B"]
                
                if (checkA == id1 && checkB == id2) {
                    return 0
                }

                if (checkA == id2 && checkB == id1) {
                    return 1
                }
            }
        }

        return -1
    }
    
    
    /**
     * 使用 Fisher-Yates 洗牌算法对数组进行随机排序
     * @param array 需要打乱的数组
     */
    public static shuffle<T>(array: T[]): T[] {
        for (let i = array.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [array[i], array[j]] = [array[j], array[i]];
        }

        return array;
    }

    // 展示二维数组
    static showMap(arr: number[][]) {
        for (var ix = 0; ix < arr.length; ix++) {
            var str = iz + " => "
            for (var iz = 0; iz < arr[ix].length; iz++) {
                str = str + arr[ix][iz] + ", "
            }
            
            console.log ( str )
        }
    }

    // 将若干个数据从数组中移除
    static removeFromArray( arr, cleans ) {
        cleans.forEach(target => {
            const cIndex = arr.indexOf(target);
            if (cIndex !== -1) {
                arr.splice(cIndex, 1)
            }
        });
    }
    

    /**
     * 将秒数转换为倒计时格式
     * @param seconds 总秒数
     * @returns 倒计时的字符串，格式为 mm:ss
     */
    static formatCountdown(seconds: number): string {
        const minutes = Math.floor(seconds / 60); // 计算分钟数
        const remainingSeconds = Math.floor(seconds % 60); // 计算剩余的秒数

        // 格式化为两位数，不足两位补零
        const minutesStr = minutes < 10 ? `0${minutes}` : `${minutes}`;
        const secondsStr = remainingSeconds < 10 ? `0${remainingSeconds}` : `${remainingSeconds}`;

        return `${minutesStr}:${secondsStr}`;
    }
    
    /**
     * 对数字进行补零操作
     * @param num 需要补零的数字
     * @param length 目标字符串的长度
     * @returns 补零后的字符串
     */
    static padZero(num: number, length: number): string {
        // 将数字转换为字符串
        let numStr = num.toString();
        
        // 循环添加 "0" 直到字符串达到指定长度
        while (numStr.length < length) {
            numStr = "0" + numStr;
        }

        return numStr;
    }

    // 重新排列，保证前 x 个顺序不变，其余的随机排列
    public static shuffleAndListArray(arr: number[], x: number): number[] {
        // 如果 x 超过了数组长度，直接返回数组
        if (x >= arr.length) {
            return arr;
        }
    
        // 保持前 x 个元素不变
        const frontPart = arr.slice(0, x);
    
        // 取出后面需要打乱的部分
        const backPart = arr.slice(x);
    
        // 使用 Fisher-Yates 洗牌算法打乱后面的部分
        for (let i = backPart.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [backPart[i], backPart[j]] = [backPart[j], backPart[i]];
        }
    
        // 合并前 x 个不变的部分和打乱的部分
        return frontPart.concat(backPart);
    }
}


